package com.sumainfor.pc.gmio.service.impl.tenant;

import com.sumainfor.common.Constants;
import com.sumainfor.common.util.ContextUtils;
import com.sumainfor.common.util.CustomMap;
import com.sumainfor.common.util.FieldCheckUtil;
import com.sumainfor.common.util.JsonResult;
import com.sumainfor.common.utlis.*;
import com.sumainfor.common.wechat.WeChatConfig;
import com.sumainfor.common.wechat.WxEncodeUtil;
import com.sumainfor.pc.gmio.dao.SeTenantBillMapper;
import com.sumainfor.pc.gmio.dao.UtilsMapper;
import com.sumainfor.pc.gmio.dao.tenant.BillMapper;
import com.sumainfor.pc.gmio.feign.BaseTenantFeign;
import com.sumainfor.pc.gmio.feign.Zfeign.ZzuulFeign;
import com.sumainfor.pc.gmio.feign.ZuulFeign.ZuulFeign;
import com.sumainfor.pc.gmio.feign.extend.HouseFeign;
import net.sf.json.JSONArray;
import org.apache.commons.collections.MapUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import java.awt.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 功能描述:
 * 账单
 *
 * @Auther: zhlu
 * @Date: 2019/3/24 11:20
 * @Description:
 */
@Service
public class BillService {
    private ReentrantLock lock = new ReentrantLock(false);

    Logger log = LoggerFactory.getLogger(BillService.class);

    @Autowired
    BillMapper BillMapper;

    @Autowired
    ZuulFeign ZuulFeign;

    @Autowired
    UtilsMapper utilsMapper;

    @Autowired
    HouseFeign HouseFeign;

    @Autowired
    BaseTenantFeign BaseTenantFeign;

    @Autowired
    ZzuulFeign ZzuulFeign;

    @Autowired
    SeTenantBillMapper seTenantBillMapper;

    String PayId;

    /**
     * 功能描述:
     * 根据合同编号获取当前租客首月房租账单
     *
     * @Author zhlu
     * @Description //TODO
     * @Date 2019/3/24 11:27
     */
    public Map<String, Object> getFirsMonRent(Map<String, Object> params) throws Exception {
        log.info("params----" + params);
        Map<String, Object> wecaht = new HashMap<String, Object>();
        //根据合同编号获取租客首月房租账单，为微信支付准备
        Map<String, Object> getFirsMonRent = BillMapper.getFirsMonRent(params);

        //获取权限当前公司的微信支付
        JsonResult<Map<String, Object>> jsonResult = ZuulFeign.getAreaPayMap(new HashMap<String, Object>() {{
            put("AreaId", getFirsMonRent.get("CorId"));//当前归属公司
        }});
        if (jsonResult.isSuccess() == false) {//如果网关查询失败就用默认的
            getFirsMonRent.put("ServeType", "2");//支付模式      1.服务商模式   2.普通商户
            getFirsMonRent.put("MchId", WeChatConfig.DEFAULT_MCH_ID);//默认商户号
            getFirsMonRent.put("AppSecret", WeChatConfig.DEFAULT_KEY);//默认微信AppSecret
        } else {
            Map<String, Object> getAreaPayMap = jsonResult.getResult();
            if (getAreaPayMap != null && getAreaPayMap.size() > 0) {//获取权限当前公司的微信支付不等于空
                getFirsMonRent.putAll(getAreaPayMap);//把权限查询过来的微信支付资料赋值给当前对象
            } else {
                getFirsMonRent.put("ServeType", "2");//支付模式      1.服务商模式   2.普通商户
                getFirsMonRent.put("MchId", WeChatConfig.DEFAULT_MCH_ID);//默认商户号
                getFirsMonRent.put("AppSecret", WeChatConfig.DEFAULT_KEY);//默认微信AppSecret
            }
        }

        //如果首月账单有值
        if (getFirsMonRent != null && getFirsMonRent.size() > 0) {
            //根据账单编号获取账单未支付账单资料
            Map<String, Object> getPayWechat = BillMapper.getPayWechat(new HashMap<String, Object>() {{
                put("SouType", getFirsMonRent.get("BiType"));
                put("Source", getFirsMonRent.get("BiId"));
            }});
            //说明有该账单的微信未支付资料，就直接拿过来
            if (getPayWechat != null && getPayWechat.size() > 0) {
                wecaht.putAll(getPayWechat);
            } else {//没有就生成微信支付的资料，并且保存下来
                Map<String,Object>wecaht2=new HashMap<String,Object>();
                if (getFirsMonRent.get("ServeType").equals(1) || getFirsMonRent.get("ServeType").toString() == "1") {
                    wecaht2.put("SubMchId", getFirsMonRent.get("SubMchId"));//父商户号
                }
                wecaht2.put("ServeType", getFirsMonRent.get("ServeType"));//支付模式      1.服务商模式   2.普通商户
                wecaht2.put("MchId", getFirsMonRent.get("MchId"));//当前商户号
                wecaht2.put("AppSecret", getFirsMonRent.get("AppSecret"));//微信AppSecret
                wecaht2.put("body", getFirsMonRent.get("BiName"));//商品描述
                wecaht2.put("detail", getFirsMonRent.get("BillExplain"));//商品详情
                wecaht2.put("payord", getFirsMonRent.get("BiId"));//微信账单号，直接拿账单编号
                wecaht2.put("remoteIp", params.get("remoteIp"));//用户IP
                wecaht2.put("uopid", params.get("uopid"));//用户openID

                //优惠券相关
                if(FieldCheckUtil.isMapFieldNotNull(params,new String[]{"CouId"})){
                    JsonResult jsonResultCou=BaseTenantFeign.getTenantCouCount(new HashMap<String,Object>(){{
                        put("CouId",params.get("CouId"));
                        put("TenId",params.get("TenId"));
                    }});
                    //返回成功
                    if(jsonResultCou.isSuccess()==true){
                        Map<String,Object> getTenantCouCount=(Map<String,Object>) jsonResultCou.getResult();
                        //优惠券大于0
                        if(MapUtils.isNotEmpty(getTenantCouCount)){
                            //账单金额
                            double BiMoney=Double.valueOf(getFirsMonRent.get("BiMoney").toString());
                            //优惠券金额
                            double Facevalue=Double.valueOf(getTenantCouCount.get("Facevalue").toString());
                            wecaht2.put("amount",CompuUtils.reduce(BiMoney,Facevalue));//商品总价
                        }
                    }
                }else{
                    wecaht2.put("amount", getFirsMonRent.get("BiMoney"));//商品总价
                }

                log.info("微信准备资料wecaht2--------------"+wecaht2);


                //微信支付资料
                Map<String, Object> wecaht1 = WxEncodeUtil.WechatSign(wecaht2);

                log.info("微信返回资料wecaht1--------------"+wecaht1);


                //新增至微信未完成支付信息里面。做二次发起用
                BillMapper.AddPayWechat(new HashMap<String, Object>() {{
                    putAll(wecaht1);
                    put("appId", WeChatConfig.APP_ID);
                    put("SouType", "1");
                    put("Source", getFirsMonRent.get("BiId"));
                }});
                wecaht.putAll(wecaht1);
                wecaht.put("SouType", 1);//房租
                wecaht.put("Source", getFirsMonRent.get("BiId"));
            }
        }
        return wecaht;
    }

    /**
     * 功能描述:
     * 微信支付完成验证与操作
     *
     * @Author zhlu
     * @Description //TODO
     * @Date 2019/3/27 11:37
     */
    @Transactional(rollbackFor = Exception.class)
    public JsonResult WechatPaymentCompleted(Map<String, Object> params) throws Exception {
        log.info("params------------"+params);
        JsonResult result = new JsonResult();
        Map<String, Object> resultMap = new HashMap<String, Object>();
        //根据账单编号获取账单资料
        Map<String, Object> getKeyBillMap = BillMapper.getKeyBillMap(params);
        //根据当前账单编号和合同编号获取当前账单的其他首月账单
        Map<String, Object> getBillPayMonRentOther = BillMapper.getBillPayMonRentOther(new HashMap<String, Object>() {{
            put("BiType", "1");//账单类型  1.房租（合同） 2.公共事业费  3.维修费用 4.延期退审核  5.其他费用  6.退租账单 7.夜间开门
            put("FirstMon", "1");//房租账单是否是首月    0否   1.是
            put("Source", getKeyBillMap.get("Source"));//账单来源编号（根据账单类型）
            put("BiId", params.get("BiId"));//账单编号
        }});

        //获取权限当前公司的微信支付
        JsonResult<Map<String, Object>> jsonResult = ZuulFeign.getAreaPayMap(new HashMap<String, Object>() {{
            put("AreaId", getKeyBillMap.get("CorId"));//当前归属公司
        }});

        //修改处理
        Map<String, Object> commonUpdateParms = new HashMap<String, Object>();
        commonUpdateParms.put("BiId", params.get("BiId"));//唐巢账单编号
        commonUpdateParms.put("term", "1");// 创建端 Insert端： 1 租客端 2市场部 3 工程部   4运营部   5财务部  6总经办 7发展部
        commonUpdateParms.put("fnc",
                this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
        ParamsCommon.commonUpdateParms(commonUpdateParms);

        if (jsonResult.isSuccess() == true) {//如果网关查询返回成功，就去查询当前订单
            Map<String, Object> Wechat = new HashMap<String, Object>();
            Map<String, Object> getAreaPayMap = jsonResult.getResult();
            if (getAreaPayMap != null && getAreaPayMap.size() > 0) {//获取权限当前公司的微信支付不等于空
                Wechat.putAll(getAreaPayMap);//把权限查询过来的微信支付资料赋值给当前对象
                Wechat.put("payord", params.get("BiId"));//微信订单号
            } else {
                Wechat.put("payord", params.get("BiId"));//微信订单号
                Wechat.put("ServeType", "2");//支付模式      1.服务商模式   2.普通商户
                Wechat.put("MchId", WeChatConfig.DEFAULT_MCH_ID);//默认商户号
                Wechat.put("AppSecret", WeChatConfig.DEFAULT_KEY);//默认微信AppSecret
            }

            //根据当前账单编号去微信查询当前账单状态
            Map<String, Object> wechatOrderQuery = WxEncodeUtil.wechatOrderQuery(Wechat);
            //说明账单支付是成功的。
            if (wechatOrderQuery.get("messageCode").equals("0") || wechatOrderQuery.toString() == "0") {

                //查询微信订单支付成功
                if (wechatOrderQuery.get("trade_state").equals("SUCCESS")) {
                    lock.lock();
                    try {
                        try {
                            //支付信息
                            Map<String, Object> payId = utilsMapper.getUUID(new HashMap<String, Object>() {{
                                put("uuid", "PayId");
                                put("database", Constants.DATA_SOURCE_GMIO);
                                put("surface", "tcgmio_bill_pay");
                            }});
                            if (payId != null) {
                                int number = Integer.valueOf(payId.get("uuid").toString());
                                PayId = ComUtils.getLocalTrmSeqNum("zf", number);
                            } else {
                                PayId = ComUtils.getLocalTrmSeqNum("zf", 0);
                            }

                            //所有新增处理
                            Map<String, Object> commonInsertParms = new HashMap<String, Object>();
                            commonInsertParms.put("term", "1");// 创建端 Insert端： 1 租客端 2市场部 3 工程部   4运营部   5财务部  6总经办 7发展部
                            commonInsertParms.put("fnc",
                                    this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
                            ParamsCommon.commonInsertParms(commonInsertParms);

                            Map<String, Object> AddPayWechat = new HashMap<String, Object>();
                            AddPayWechat.putAll(commonInsertParms);
                            AddPayWechat.put("PayId", PayId);//合同编号
                            AddPayWechat.put("TenId", params.get("TenId"));//用户编号
                            AddPayWechat.put("Shape", "0");//支付形式   0.线上   1.线下
                            AddPayWechat.put("PayMode", "1");//支付方式  1.微信  2.支付宝
                            AddPayWechat.put("TransactionId", wechatOrderQuery.get("transaction_id"));//微信支付订单号	该字段只有线上微信支付才有
                            AddPayWechat.put("PayTime", wechatOrderQuery.get("time_end"));//支付时间
                            AddPayWechat.put("BiMoney", getKeyBillMap.get("BiMoney"));//本次账单金额
                            double total_fee = Double.valueOf(wechatOrderQuery.get("total_fee").toString());
                            AddPayWechat.put("PayMoney", CompuUtils.div(total_fee, 100, 2));//支付金额
                            AddPayWechat.put("PatStats", "2");//支付状态    1.未支付  2.支付成功
                            //优惠券相关
                            if(FieldCheckUtil.isMapFieldNotNull(params,new String[]{"CouId"})){
                                JsonResult jsonResultCou=BaseTenantFeign.getTenantCouCount(new HashMap<String,Object>(){{
                                    put("CouId",params.get("CouId"));
                                    put("TenId",params.get("TenId"));
                                }});
                                //返回成功
                                if(jsonResultCou.isSuccess()==true){
                                    Map<String,Object> getTenantCouCount=(Map<String,Object>) jsonResultCou.getResult();
                                    //优惠券大于0
                                    if(MapUtils.isNotEmpty(getTenantCouCount)){
                                        Map<String,Object>cou=new HashMap<String,Object>();
                                        cou.put("CouId",params.get("CouId"));
                                        cou.put("TenId",params.get("TenId"));
                                        //修改优惠券已使用
                                        BaseTenantFeign.UpdateTenantCou(cou);
                                        AddPayWechat.put("Couponcd", params.get("CouId"));//优惠券编号
                                        AddPayWechat.put("Couponamt",getTenantCouCount.get("Facevalue"));//优惠券金额
                                    }
                                }
                            }

                            log.info("AddPayWechat支付信息-------------"+AddPayWechat);

                            //新增支付信息
                            BillMapper.AddBillPay(AddPayWechat);

                            //修改当前房租账单为支付成功
                            BillMapper.UpdateBill(new HashMap<String, Object>() {{
                                putAll(commonUpdateParms);
                                put("PayId", PayId);//支付信息编号
                                put("Status", 2);//账单状态   1.待支付  2.支付完成
                                put("Abnormal", 0);//账单异常状态   0正常   1异常
                            }});
                            log.info("-----------------");
                            log.info("-----------------");
                            log.info("-----------------"+getBillPayMonRentOther);
                            log.info("-----------------");
                            log.info("-----------------");
                            if (getBillPayMonRentOther != null || getBillPayMonRentOther.size() > 0) {
                                log.info("++++++++++++++++++++++++++++");
                                log.info("-----------------");
                                log.info("-----------------getBillPayMonRentOther当前账单的其他账单有值");
                                log.info("-----------------");
                                log.info("-----------------");
                                //水电押金未支付
                                if (getBillPayMonRentOther.get("Status").equals(1) || Integer.valueOf(getBillPayMonRentOther.get("Status").toString())==1) {
                                    //修改合同状态
                                    HouseFeign.UpdatePayPact(new HashMap<String, Object>() {{
                                        put("PaId", getKeyBillMap.get("Source"));//合同编号
                                        put("RentStatus", "2");//房租/押金     支付状态   0不需要支付   1.待支付   2支付完成
                                    }});

                                    resultMap.put("PayStatus", "1");//支付宝线下转账是否成功  0成功   1未支付   2支付宝待审核
                                    resultMap.put("WechatStatus", "0");//微信线上是否支付成功   0成功  1未支付
                                    return result.put(resultMap);
                                }
                                //水电押金支付成功，并且审核成功
                                if (getBillPayMonRentOther.get("Status").equals(2) || Integer.valueOf(getBillPayMonRentOther.get("Status").toString())==2) {
                                    //修改合同状态
                                    HouseFeign.UpdatePayPact(new HashMap<String, Object>() {{
                                        put("PaId", getKeyBillMap.get("Source"));//合同编号
                                        put("RentStatus", "2");//房租/押金     支付状态   0不需要支付   1.待支付   2支付完成
                                        put("IfFlowPay", "2");//电子合同是否支付     0无状态   1已完成未支付 2已完成已支付（该状态只有电子合同状态为2才有用）
                                    }});

                                    resultMap.put("PayStatus", "0");//支付宝线下转账是否成功  0成功   1未支付   2支付宝待审核
                                    resultMap.put("WechatStatus", "0");//微信线上是否支付成功   0成功  1未支付
                                    return result.put(resultMap);
                                }
                                //水电押金已上传
                                if (getBillPayMonRentOther.get("Status").equals(3) || Integer.valueOf(getBillPayMonRentOther.get("Status").toString())==3) {
                                    //修改合同状态
                                    HouseFeign.UpdatePayPact(new HashMap<String, Object>() {{
                                        put("PaId", getKeyBillMap.get("Source"));//合同编号
                                        put("RentStatus", "2");//房租/押金     支付状态   0不需要支付   1.待支付   2支付完成
                                    }});

                                    resultMap.put("PayStatus", "2");//支付宝线下转账是否成功  0成功   1未支付   2支付宝待审核
                                    resultMap.put("WechatStatus", "0");//微信线上是否支付成功   0成功  1未支付
                                    return result.put(resultMap);
                                }
                                if (!FieldCheckUtil.isMapFieldNotNull(getBillPayMonRentOther, new String[]{"PayId"}) &&
                                        !FieldCheckUtil.isMapFieldNotNull(getBillPayMonRentOther, new String[]{"Status"})) {
                                    //修改合同状态
                                    HouseFeign.UpdatePayPact(new HashMap<String, Object>() {{
                                        put("PaId", getKeyBillMap.get("Source"));//合同编号
                                        put("RentStatus", "2");//房租/押金     支付状态   0不需要支付   1.待支付   2支付完成
                                        put("IfFlowPay", "2");//电子合同是否支付     0无状态   1已完成未支付 2已完成已支付（该状态只有电子合同状态为2才有用）
                                    }});

                                    resultMap.put("PayStatus", "1");//支付宝线下转账是否成功  0成功   1未支付
                                    resultMap.put("WechatStatus", "0");//微信线上是否支付成功   0成功  1未支付
                                    return result.put(resultMap);
                                }
                            } else {
                                //修改合同状态
                                HouseFeign.UpdatePayPact(new HashMap<String, Object>() {{
                                    put("PaId", getKeyBillMap.get("Source"));//合同编号
                                    put("RentStatus", "2");//房租/押金     支付状态   0不需要支付   1.待支付   2支付完成
                                    put("IfFlowPay", "2");//电子合同是否支付     0无状态   1已完成未支付 2已完成已支付（该状态只有电子合同状态为2才有用）
                                }});

                                resultMap.put("PayStatus", "0");//支付宝线下转账是否成功  0成功   1未支付
                                resultMap.put("WechatStatus", "0");//微信线上是否支付成功   0成功  1未支付
                                return result.put(resultMap);
                            }

                        } catch (NumberFormatException e) {
                            e.printStackTrace();
                            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                        }
                    } finally {
                        lock.unlock();
                    }
                }//查询微信支付中除开支付成功状态，其他状态。先返回支付成功，并且标明账单异常
                else {
                    BillMapper.UpdateBill(new HashMap<String, Object>() {{
                        putAll(commonUpdateParms);
                        put("Abnormal", 1);//账单异常状态   0正常   1异常
                        put("Status", 2);//账单状态   1.待支付  2.支付完成
                    }});

                    if (getBillPayMonRentOther != null || getBillPayMonRentOther.size() > 0) {
                        //水电押金未支付
                        if (getBillPayMonRentOther.get("Status").equals(1) || Integer.valueOf(getBillPayMonRentOther.get("Status").toString())==1) {
                            //修改合同状态
                            HouseFeign.UpdatePayPact(new HashMap<String, Object>() {{
                                put("PaId", getKeyBillMap.get("Source"));//合同编号
                                put("RentStatus", "2");//房租/押金     支付状态   0不需要支付   1.待支付   2支付完成
                            }});

                            resultMap.put("PayStatus", "1");//支付宝线下转账是否成功  0成功   1未支付   2支付宝待审核
                            resultMap.put("WechatStatus", "0");//微信线上是否支付成功   0成功  1未支付
                            return result.put(resultMap);
                        }
                        //水电押金支付成功，并且审核成功
                        if (getBillPayMonRentOther.get("Status").equals(2) || Integer.valueOf(getBillPayMonRentOther.get("Status").toString())==2) {
                            //修改合同状态
                            HouseFeign.UpdatePayPact(new HashMap<String, Object>() {{
                                put("PaId", getKeyBillMap.get("Source"));//合同编号
                                put("RentStatus", "2");//房租/押金     支付状态   0不需要支付   1.待支付   2支付完成
                                put("IfFlowPay", "2");//电子合同是否支付     0无状态   1已完成未支付 2已完成已支付（该状态只有电子合同状态为2才有用）
                            }});

                            resultMap.put("PayStatus", "0");//支付宝线下转账是否成功  0成功   1未支付   2支付宝待审核
                            resultMap.put("WechatStatus", "0");//微信线上是否支付成功   0成功  1未支付
                            return result.put(resultMap);
                        }
                        //水电押金已上传
                        if (getBillPayMonRentOther.get("Status").equals(3) || Integer.valueOf(getBillPayMonRentOther.get("Status").toString())==3) {
                            //修改合同状态
                            HouseFeign.UpdatePayPact(new HashMap<String, Object>() {{
                                put("PaId", getKeyBillMap.get("Source"));//合同编号
                                put("RentStatus", "2");//房租/押金     支付状态   0不需要支付   1.待支付   2支付完成
                            }});

                            resultMap.put("PayStatus", "2");//支付宝线下转账是否成功  0成功   1未支付   2支付宝待审核
                            resultMap.put("WechatStatus", "0");//微信线上是否支付成功   0成功  1未支付
                            return result.put(resultMap);
                        }
                        if (!FieldCheckUtil.isMapFieldNotNull(getBillPayMonRentOther, new String[]{"PayId"}) &&
                                !FieldCheckUtil.isMapFieldNotNull(getBillPayMonRentOther, new String[]{"Status"})) {
                            //修改合同状态
                            HouseFeign.UpdatePayPact(new HashMap<String, Object>() {{
                                put("PaId", getKeyBillMap.get("Source"));//合同编号
                                put("RentStatus", "2");//房租/押金     支付状态   0不需要支付   1.待支付   2支付完成
                                put("IfFlowPay", "2");//电子合同是否支付     0无状态   1已完成未支付 2已完成已支付（该状态只有电子合同状态为2才有用）
                            }});

                            resultMap.put("PayStatus", "1");//支付宝线下转账是否成功  0成功   1未支付
                            resultMap.put("WechatStatus", "0");//微信线上是否支付成功   0成功  1未支付
                            return result.put(resultMap);
                        }
                    } else {
                        //修改合同状态
                        HouseFeign.UpdatePayPact(new HashMap<String, Object>() {{
                            put("PaId", getKeyBillMap.get("Source"));//合同编号
                            put("RentStatus", "2");//房租/押金     支付状态   0不需要支付   1.待支付   2支付完成
                            put("IfFlowPay", "2");//电子合同是否支付     0无状态   1已完成未支付 2已完成已支付（该状态只有电子合同状态为2才有用）
                        }});

                        resultMap.put("PayStatus", "0");//支付宝线下转账是否成功  0成功   1未支付
                        resultMap.put("WechatStatus", "0");//微信线上是否支付成功   0成功  1未支付
                        return result.put(resultMap);
                    }

                }
            }
            //账单查询失败，就把错误信息返回
            else if (wechatOrderQuery.get("messageCode").equals("400") || wechatOrderQuery.toString() == "400") {
                result.putSuccess(wechatOrderQuery.get("messageStr").toString());
                return result;
            }
        } else {//如果网关查询失败，把当前账单标记为异常，并且标记当前账单支付完成
            BillMapper.UpdateBill(new HashMap<String, Object>() {{
                putAll(commonUpdateParms);
                put("Abnormal", 1);//账单异常状态   0正常   1异常
                put("Status", 2);//账单状态   1.待支付  2.支付完成
            }});

            if (getBillPayMonRentOther != null || getBillPayMonRentOther.size() > 0) {
                //水电押金未支付
                //水电押金未支付
                if (getBillPayMonRentOther.get("Status").equals(1) || Integer.valueOf(getBillPayMonRentOther.get("Status").toString())==1) {
                    //修改合同状态
                    HouseFeign.UpdatePayPact(new HashMap<String, Object>() {{
                        put("PaId", getKeyBillMap.get("Source"));//合同编号
                        put("RentStatus", "2");//房租/押金     支付状态   0不需要支付   1.待支付   2支付完成
                    }});

                    resultMap.put("PayStatus", "1");//支付宝线下转账是否成功  0成功   1未支付   2支付宝待审核
                    resultMap.put("WechatStatus", "0");//微信线上是否支付成功   0成功  1未支付
                    return result.put(resultMap);
                }
                //水电押金支付成功，并且审核成功
                if (getBillPayMonRentOther.get("Status").equals(2) || Integer.valueOf(getBillPayMonRentOther.get("Status").toString())==2) {
                    //修改合同状态
                    HouseFeign.UpdatePayPact(new HashMap<String, Object>() {{
                        put("PaId", getKeyBillMap.get("Source"));//合同编号
                        put("RentStatus", "2");//房租/押金     支付状态   0不需要支付   1.待支付   2支付完成
                        put("IfFlowPay", "2");//电子合同是否支付     0无状态   1已完成未支付 2已完成已支付（该状态只有电子合同状态为2才有用）
                    }});

                    resultMap.put("PayStatus", "0");//支付宝线下转账是否成功  0成功   1未支付   2支付宝待审核
                    resultMap.put("WechatStatus", "0");//微信线上是否支付成功   0成功  1未支付
                    return result.put(resultMap);
                }
                //水电押金已上传
                if (getBillPayMonRentOther.get("Status").equals(3) || Integer.valueOf(getBillPayMonRentOther.get("Status").toString())==3) {
                    //修改合同状态
                    HouseFeign.UpdatePayPact(new HashMap<String, Object>() {{
                        put("PaId", getKeyBillMap.get("Source"));//合同编号
                        put("RentStatus", "2");//房租/押金     支付状态   0不需要支付   1.待支付   2支付完成
                    }});

                    resultMap.put("PayStatus", "2");//支付宝线下转账是否成功  0成功   1未支付   2支付宝待审核
                    resultMap.put("WechatStatus", "0");//微信线上是否支付成功   0成功  1未支付
                    return result.put(resultMap);
                }
                if (!FieldCheckUtil.isMapFieldNotNull(getBillPayMonRentOther, new String[]{"PayId"}) &&
                        !FieldCheckUtil.isMapFieldNotNull(getBillPayMonRentOther, new String[]{"Status"})) {
                    //修改合同状态
                    HouseFeign.UpdatePayPact(new HashMap<String, Object>() {{
                        put("PaId", getKeyBillMap.get("Source"));//合同编号
                        put("RentStatus", "2");//房租/押金     支付状态   0不需要支付   1.待支付   2支付完成
                        put("IfFlowPay", "2");//电子合同是否支付     0无状态   1已完成未支付 2已完成已支付（该状态只有电子合同状态为2才有用）
                    }});

                    resultMap.put("PayStatus", "1");//支付宝线下转账是否成功  0成功   1未支付
                    resultMap.put("WechatStatus", "0");//微信线上是否支付成功   0成功  1未支付
                    return result.put(resultMap);
                }
            } else {
                //修改合同状态
                HouseFeign.UpdatePayPact(new HashMap<String, Object>() {{
                    put("PaId", getKeyBillMap.get("Source"));//合同编号
                    put("RentStatus", "2");//房租/押金     支付状态   0不需要支付   1.待支付   2支付完成
                    put("IfFlowPay", "2");//电子合同是否支付     0无状态   1已完成未支付 2已完成已支付（该状态只有电子合同状态为2才有用）
                }});

                resultMap.put("PayStatus", "0");//支付宝线下转账是否成功  0成功   1未支付
                resultMap.put("WechatStatus", "0");//微信线上是否支付成功   0成功  1未支付
                return result.put(resultMap);
            }
        }
        return result;
    }

    /**
     * 功能描述: 
     * 根据合同编号获取当前合同下的首月房租账单和水电账单
     * @Author zhlu
     * @Description //TODO
     * @Date 2019/3/29 10:05
     */
    public Map<String,Object>getBillMonRentList(Map<String,Object>params){
        Map<String,Object>result=new HashMap<String,Object>();
        List<Map<String,Object>>getBillMonRentList=BillMapper.getBillMonRentList(params);
        for (Map<String,Object> map:getBillMonRentList){
            //房租类型   1.房租房租押金   2.水电押金   (账单类型为1)
            if(map.get("DepositType").equals(1)||Integer.valueOf(map.get("DepositType").toString())==1){
                //账单状态   1.待支付  2.支付完成
                if(map.get("Status").equals(1)||Integer.valueOf(map.get("Status").toString())==1){
                    result.put("WechatStatus", "1");//微信线上是否支付成功   0成功  1未支付
                }else if(map.get("Status").equals(2)||Integer.valueOf(map.get("Status").toString())==2){
                    result.put("WechatStatus", "0");//微信线上是否支付成功   0成功  1未支付
                }
            }else if(map.get("DepositType").equals(2)||Integer.valueOf(map.get("DepositType").toString())==2){
                //账单状态   1.待支付  2.支付完成
                if(map.get("Status").equals(1)||Integer.valueOf(map.get("Status").toString())==1){
                    result.put("PayStatus", "1");//支付宝线下转账是否成功  0成功   1未支付
                }else if(map.get("Status").equals(2)||Integer.valueOf(map.get("Status").toString())==2){
                    result.put("PayStatus", "2");//支付宝线下转账是否成功  0成功   1未支付//没有审核支付成功就好

                }else if(map.get("Status").equals(3)||Integer.valueOf(map.get("Status").toString())==3){
                    result.put("PayStatus", "2");//支付宝线下转账是否成功  0成功   1未支付   2支付宝待审核
                }
            }
            if(FieldCheckUtil.isMapFieldNotNull(map,new String[]{"CorId"})){
                result.put("AreaId",map.get("CorId"));//当前账单归属公司，涉及到支付。不同公司走不同账户
            }else{
                result.put("AreaId",null);//当前账单归属公司，涉及到支付。不同公司走不同账户
            }
        }
        log.info("result--------"+result);
        return result;
    }

    /**
     * 功能描述:
     * 支付宝转账
     * @Author zhlu
     * @Description //TODO
     * @Date 2019/3/29 19:46
     */
    @Transactional(rollbackFor = Exception.class)
    public JsonResult PayOffline(Map<String,Object>params){



        JsonResult result=new JsonResult();
        Map<String,Object>resultMap=new HashMap<String,Object>();
        //根据合同编号获取租客首月房租账单，为支付宝支付做准备(获取的是首次水电押金)
        Map<String, Object> getFirsMonRent = BillMapper.getFirsMonRent(params);
        //根据当前账单编号和合同编号获取当前账单的其他首月账单(水电押金)
        Map<String, Object> getBillPayMonRentOther = BillMapper.getBillPayMonRentOther(new HashMap<String, Object>() {{
            put("BiType", "1");//账单类型  1.房租（合同） 2.公共事业费  3.维修费用 4.延期退审核  5.其他费用  6.退租账单 7.夜间开门
            put("FirstMon", "1");//房租账单是否是首月    0否   1.是
            put("Source", getFirsMonRent.get("Source"));//账单来源编号（根据账单类型）
            put("BiId", getFirsMonRent.get("BiId"));//账单编号
        }});

        //所有新增处理
        Map<String, Object> commonInsertParms = new HashMap<String, Object>();
        commonInsertParms.put("term", "1");// 创建端 Insert端： 1 租客端 2市场部 3 工程部   4运营部   5财务部  6总经办 7发展部
        commonInsertParms.put("fnc",
                this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
        ParamsCommon.commonInsertParms(commonInsertParms);

        //修改处理
        Map<String, Object> commonUpdateParms = new HashMap<String, Object>();
        commonUpdateParms.put("term", "1");// 创建端 Insert端： 1 租客端 2市场部 3 工程部   4运营部   5财务部  6总经办 7发展部
        commonUpdateParms.put("fnc",
                this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
        ParamsCommon.commonUpdateParms(commonUpdateParms);

        //如果首月账单有值
        if (getFirsMonRent != null && getFirsMonRent.size() > 0) {
            lock.lock();
            try {
                //支付信息
                Map<String, Object> payId = utilsMapper.getUUID(new HashMap<String, Object>() {{
                    put("uuid", "PayId");
                    put("database", Constants.DATA_SOURCE_GMIO);
                    put("surface", "tcgmio_bill_pay");
                }});
                if (payId != null) {
                    int number = Integer.valueOf(payId.get("uuid").toString());
                    PayId = ComUtils.getLocalTrmSeqNum("zf", number);
                } else {
                    PayId = ComUtils.getLocalTrmSeqNum("zf", 0);
                }

                Map<String, Object> AddPayWechat = new HashMap<String, Object>();
                AddPayWechat.putAll(commonInsertParms);
                AddPayWechat.put("PayId", PayId);//合同编号
                AddPayWechat.put("TenId", params.get("TenId"));//用户编号
                AddPayWechat.put("Shape", "1");//支付形式   0.线上   1.线下
                AddPayWechat.put("PayMode", "2");//支付方式  1.微信  2.支付宝
                AddPayWechat.put("BiMoney", getFirsMonRent.get("BiMoney"));//本次账单金额
//                AddPayWechat.put("Couponcd", params.get("Couponcd"));//优惠券编号
//                AddPayWechat.put("Couponamt", wechatOrderQuery.get("Couponamt"));//优惠券金额
                List<String>PayFileList= JSONArray.fromObject(params.get("PayFile"));
                AddPayWechat.put("PayFile",FileSubufferUtils.ListStrFlieStringUtils(PayFileList));//支付凭证（如果是线下需要凭证，图片）
                AddPayWechat.put("PatStatus", "1");//支付状态    支付订单审核状态   0订单无需审核（线上）   1.待审核 2.审核驳回  3.审核通过
                AddPayWechat.put("PatStats", "2");//支付状态    1.未支付   2.支付成功

                //优惠券相关
                if(FieldCheckUtil.isMapFieldNotNull(params,new String[]{"CouId"})){
                    JsonResult jsonResultCou=BaseTenantFeign.getTenantCouCount(new HashMap<String,Object>(){{
                        put("CouId",params.get("CouId"));
                        put("TenId",params.get("TenId"));
                    }});
                    //返回成功
                    if(jsonResultCou.isSuccess()==true){
                        Map<String,Object> getTenantCouCount=(Map<String,Object>) jsonResultCou.getResult();
                        //优惠券大于0
                        if(MapUtils.isNotEmpty(getTenantCouCount)){
                            Map<String,Object>cou=new HashMap<String,Object>();
                            cou.put("CouId",params.get("CouId"));
                            cou.put("TenId",params.get("TenId"));
                            //修改优惠券已使用
                            BaseTenantFeign.UpdateTenantCou(cou);
                            AddPayWechat.put("Couponcd", params.get("CouId"));//优惠券编号
                            AddPayWechat.put("Couponamt",getTenantCouCount.get("Facevalue"));//优惠券金额
                        }
                    }
                }
                //新增支付信息
                BillMapper.AddBillPay(AddPayWechat);
                //修改账单为支付成功
                BillMapper.UpdateBill(new HashMap<String, Object>() {{
                    putAll(commonUpdateParms);
                    put("BiId", getFirsMonRent.get("BiId"));//支付信息编号
                    put("PayId", PayId);//账单编号
                    put("Status", 2);//账单状态   1.待支付  2.支付完成  3待审核
                    put("Abnormal", 0);//账单异常状态   0正常   1异常
                }});

                //新增逻辑.如果有固定的水燃宽的账单.在这里也要把账单状态改为已支付

                Map<String,Object> GuDingBill = new HashMap<>();
                GuDingBill.put("BiType",2);//类型为公共事业费
                GuDingBill.put("PaId",params.get("PaId"));//来源为账单编号
                GuDingBill.put("FirstMon",1);//是否首月
                List<Map<String,Object>> getGuDingWEGList = BillMapper.getGuDingWEG(GuDingBill);
                if (getGuDingWEGList!=null&&getGuDingWEGList.size()>0){//说明上传凭证不止需要支付水电押金,还有固定金额的水费燃气宽带等

                    for(Map<String,Object> map1:getGuDingWEGList){

                        String PayIds="";
                        //支付信息
                        Map<String, Object> payIdMap = utilsMapper.getUUID(new HashMap<String, Object>() {{
                            put("uuid", "PayId");
                            put("database", Constants.DATA_SOURCE_GMIO);
                            put("surface", "tcgmio_bill_pay");
                        }});
                        if (payIdMap != null) {
                            int number = Integer.valueOf(payIdMap.get("uuid").toString());
                            PayIds = ComUtils.getLocalTrmSeqNum("zf", number);
                        } else {
                            PayIds = ComUtils.getLocalTrmSeqNum("zf", 0);
                        }

                        Map<String, Object> GuDingMap = new HashMap<String, Object>();
                        GuDingMap.putAll(commonInsertParms);
                        GuDingMap.put("PayId", PayIds);//支付信息编号
                        GuDingMap.put("TenId", params.get("TenId"));//用户编号
                        GuDingMap.put("Shape", "1");//支付形式   0.线上   1.线下
                        GuDingMap.put("PayMode", "2");//支付方式  1.微信  2.支付宝
                        GuDingMap.put("BiMoney", map1.get("BiMoney"));//本次账单金额
                        List<String>PayFileLists= JSONArray.fromObject(params.get("PayFile"));
                        GuDingMap.put("PayFile",FileSubufferUtils.ListStrFlieStringUtils(PayFileLists));//支付凭证（如果是线下需要凭证，图片）
                        GuDingMap.put("PatStatus", "1");//支付状态    支付订单审核状态   0订单无需审核（线上）   1.待审核 2.审核驳回  3.审核通过
                        GuDingMap.put("PatStats", "2");//支付状态    1.未支付   2.支付成功

                        //优惠券相关
                        if(FieldCheckUtil.isMapFieldNotNull(params,new String[]{"CouId"})){
                            JsonResult jsonResultCou=BaseTenantFeign.getTenantCouCount(new HashMap<String,Object>(){{
                                put("CouId",params.get("CouId"));
                                put("TenId",params.get("TenId"));
                            }});
                            //返回成功
                            if(jsonResultCou.isSuccess()==true){
                                Map<String,Object> getTenantCouCount=(Map<String,Object>) jsonResultCou.getResult();
                                //优惠券大于0
                                if(MapUtils.isNotEmpty(getTenantCouCount)){
                                    Map<String,Object>cou=new HashMap<String,Object>();
                                    cou.put("CouId",params.get("CouId"));
                                    cou.put("TenId",params.get("TenId"));
                                    //修改优惠券已使用
                                    BaseTenantFeign.UpdateTenantCou(cou);
                                    GuDingMap.put("Couponcd", params.get("CouId"));//优惠券编号
                                    GuDingMap.put("Couponamt",getTenantCouCount.get("Facevalue"));//优惠券金额
                                }
                            }
                        }
                        //新增支付信息
                        BillMapper.AddBillPay(GuDingMap);
                        //修改账单为支付成功
                        BillMapper.UpdateBill(new HashMap<String, Object>() {{
                            putAll(commonUpdateParms);
                            put("BiId", map1.get("BiId"));//支付信息编号
                            put("PayId",GuDingMap.get("PayId"));//账单编号
                            put("Status", 2);//账单状态   1.待支付  2.支付完成  3待审核
                            put("Abnormal", 0);//账单异常状态   0正常   1异常
                        }});
                    }
                }

                //新的特价房源审核通知
                CustomMap data = CustomMap.create("MeType", 9)
                        .put("Title", "新的账单待审核")
                        .put("Content", HtmlUtil.stringToHTML(" 注意！有新的账单待审核 请及时审核！", "", Color.blue))
//                        .put("by", ContextUtils.getWxInfo().getTenId())
                        .put("term", 4);
                ZzuulFeign.AddMessage(data);

                if (getBillPayMonRentOther != null || getBillPayMonRentOther.size() > 0) {
                    log.info("-----------------");
                    log.info("-----------------");
                    log.info("-----------------"+getBillPayMonRentOther);
                    log.info("-----------------");
                    log.info("-----------------");
                    //查询微信账单是否支付成功
                    if (getBillPayMonRentOther.get("Status").equals(1) || Integer.valueOf(getBillPayMonRentOther.get("Status").toString())== 1) {
                        //修改合同状态
                        HouseFeign.UpdatePayPact(new HashMap<String, Object>() {{
                            put("PaId", params.get("PaId"));//合同编号
                            put("Hydropower", "3");//水电押金   支付状态   0不需要支付   1.待支付   2支付完成    3待审核
                        }});

                        resultMap.put("PayStatus", "0");//支付宝线下转账是否成功  0成功   1未支付
                        resultMap.put("WechatStatus", "1");//微信线上是否支付成功   0成功  1未支付
                        return result.put(resultMap);
                    }
                    //查询微信账单是否支付成功
                    if (getBillPayMonRentOther.get("Status").equals(2) || Integer.valueOf(getBillPayMonRentOther.get("Status").toString())== 2) {
                        //修改合同状态
                        HouseFeign.UpdatePayPact(new HashMap<String, Object>() {{
                            put("PaId", params.get("PaId"));//合同编号
                            put("Hydropower", "3");//水电押金   支付状态   0不需要支付   1.待支付   2支付完成    3待审核
                        }});

                        resultMap.put("PayStatus", "0");//支付宝线下转账是否成功  0成功   1未支付
                        resultMap.put("WechatStatus", "0");//微信线上是否支付成功   0成功  1未支付
                        return result.put(resultMap);
                    }
                    if (!FieldCheckUtil.isMapFieldNotNull(getBillPayMonRentOther, new String[]{"PayId"}) &&
                            !FieldCheckUtil.isMapFieldNotNull(getBillPayMonRentOther, new String[]{"Status"})) {
                        //修改合同状态
                        HouseFeign.UpdatePayPact(new HashMap<String, Object>() {{
                            put("PaId", params.get("PaId"));//合同编号
                            put("Hydropower", "3");//水电押金   支付状态   0不需要支付   1.待支付   2支付完成    3待审核
                        }});

                        resultMap.put("PayStatus", "0");//支付宝线下转账是否成功  0成功   1未支付
                        resultMap.put("WechatStatus", "1");//微信线上是否支付成功   0成功  1未支付
                        return result.put(resultMap);
                    }
                } else {
                    //修改合同状态
                    HouseFeign.UpdatePayPact(new HashMap<String, Object>() {{
                        put("PaId", params.get("PaId"));//合同编号
                        put("Hydropower", "3");//水电押金   支付状态   0不需要支付   1.待支付   2支付完成    3待审核
                    }});

                    resultMap.put("PayStatus", "0");//支付宝线下转账是否成功  0成功   1未支付
                    resultMap.put("WechatStatus", "0");//微信线上是否支付成功   0成功  1未支付
                    return result.put(resultMap);
                }



            } finally {
                lock.unlock();
            }
        }
        return result;
    }

    /**
     * 功能描述: 
     * 根据业主合同编号查询业主全部账单总数
     * @Author zhlu
     * @Description //TODO
     * @Date 2019/4/1 10:02
     */
    public Integer getOwnerBillAllCount(Map<String,Object>params){
        JsonResult<Map<String, Object>> jsonResult = HouseFeign.getOwnerBillList(params);
        if (jsonResult.isSuccess() == false) {
            params.put("owdealList",new ArrayList<String>());
        }
        params.putAll(jsonResult.getResult());
        params.put("BiOutType","1");//账单类型  1.业主   2.供应商  3.退租账单   4.公共事业费
        Integer getOwnerBillAllCount=BillMapper.getOwnerBillAllCount(params);
        return getOwnerBillAllCount;
    }

    /**
     * 功能描述: 
     * 根据业主手机号获取业主合同，然后获取业主账单资料
     * @Author zhlu
     * @Description //TODO
     * @Date 2019/4/1 14:12
     */
    public List<Map<String,Object>>getOwnerBillList(Map<String,Object>params){
        List<Map<String,Object>>getOwnerBillList=BillMapper.getOwnerBillList(params);
        return getOwnerBillList;
    }

    /**
     * 功能描述: 
     * 根据业主手机号获取业主合同，然后获取业主账单资料总数
     * @Author zhlu
     * @Description //TODO
     * @Date 2019/4/1 14:13
     */
    public Integer getOwnerBillListCount(Map<String,Object>params){
        Integer getOwnerBillListCount=BillMapper.getOwnerBillListCount(params);
        return getOwnerBillListCount;
    }

    /**
     * 功能描述: 
     * 根据租客编号和出租类型获取租客所有账单总数
     * @Author zhlu
     * @Description //TODO
     * @Date 2019/4/4 21:44
     */
    public List<Map<String,Object>>getBillAllList(Map<String,Object>params){
        List<Map<String,Object>>getBillAllList=BillMapper.getBillAllList(params);
        return getBillAllList;
    }

    /**
     * 功能描述: 
     * 根据租客编号和出租类型获取租客所有账单总数
     * @Author zhlu
     * @Description //TODO
     * @Date 2019/4/4 21:46
     */
    public Integer getBillAllListCount(Map<String,Object>params){
        Integer getBillAllListCount=BillMapper.getBillAllListCount(params);
        return getBillAllListCount;
    }

    /**
     * 功能描述: 
     * 根据账单编号和租客编号获取账单详情
     * @Author zhlu
     * @Description //TODO
     * @Date 2019/4/6 15:48
     */
    public Map<String,Object>getBillAllBiIdMap(Map<String,Object>params){
        Map<String,Object>getBillAllBiIdMap=BillMapper.getBillAllBiIdMap(params);
        getBillAllBiIdMap.put("BillExplain",getBillAllBiIdMap.get("BillExplain").toString().split(","));
        return getBillAllBiIdMap;
    }

    /**
     * 功能描述: 
     * 根据合同编号获取账单
     * @Author zhlu
     * @Description //TODO
     * @Date 2019/4/15 11:54
     */
    public Map<String,Object>getBillFeeMapFile(Map<String,Object>params){
        Map<String,Object>result=new HashMap<String,Object>();
        Map<String,Object>getBillFeeMapFile=BillMapper.getBillFeeMapFile(params);
        if(MapUtils.isNotEmpty(getBillFeeMapFile)){
            if(FieldCheckUtil.isMapFieldNotNull(getBillFeeMapFile,new String[]{"PayFile"})){
                getBillFeeMapFile.put("PayFile",getBillFeeMapFile.get("PayFile").toString().split(","));
            }else{
                getBillFeeMapFile.put("PayFile",new ArrayList<Map<String,Object>>());
            }
            result.putAll(getBillFeeMapFile);
        }else{
            result.put("PayFile",new ArrayList<Map<String,Object>>());
            result.put("PayId",null);
        }
        return result;
    }

    /**
     * 功能描述: 
     * 支付宝水电燃支付，审核之后重新支付
     * @Author zhlu
     * @Description //TODO
     * @Date 2019/4/15 21:56
     */
    @Transactional(rollbackFor = Exception.class)
    public JsonResult UpdateBillPay(Map<String,Object>params){
        JsonResult result=new JsonResult();
        Map<String,Object>resultMap=new HashMap<String,Object>();
        //修改处理
        Map<String, Object> commonUpdateParms = new HashMap<String, Object>();
        commonUpdateParms.put("term", "1");// 创建端 Insert端： 1 租客端 2市场部 3 工程部   4运营部   5财务部  6总经办 7发展部
        commonUpdateParms.put("fnc",
                this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
        ParamsCommon.commonUpdateParms(commonUpdateParms);

        //根据合同编号获取租客首月房租账单，为支付宝支付做准备
        Map<String, Object> getFirsMonRent = BillMapper.getFirsMonRent(params);
        //根据当前账单编号和合同编号获取当前账单的其他首月账单
        Map<String, Object> getBillPayMonRentOther = BillMapper.getBillPayMonRentOther(new HashMap<String, Object>() {{
            put("BiType", "1");//账单类型  1.房租（合同） 2.公共事业费  3.维修费用 4.延期退审核  5.其他费用  6.退租账单 7.夜间开门
            put("FirstMon", "1");//房租账单是否是首月    0否   1.是
            put("Source", getFirsMonRent.get("Source"));//账单来源编号（根据账单类型）
            put("BiId", getFirsMonRent.get("BiId"));//账单编号
        }});

        try {
            params.putAll(commonUpdateParms);
            List<String>PayFileList= JSONArray.fromObject(params.get("PayFile"));
            params.put("PayFile",FileSubufferUtils.ListStrFlieStringUtils(PayFileList));
            //修改水电燃账单
            BillMapper.UpdateBillPay(params);
            //修改账单为支付成功
            BillMapper.UpdateBill(new HashMap<String, Object>() {{
                putAll(commonUpdateParms);
                put("BiId", getFirsMonRent.get("BiId"));//支付信息编号
                put("PayId", PayId);//账单编号
                put("Status", 3);//账单状态   1.待支付  2.支付完成  3待审核
                put("Abnormal", 0);//账单异常状态   0正常   1异常
            }});

            //新的账单待审核通知
            CustomMap data = CustomMap.create("MeType", 9)
                    .put("Title", "新的账单待审核")
                    .put("Content", HtmlUtil.stringToHTML("注意！有新的账单待审核 请及时审核！", "", Color.blue))
                    .put("by", ContextUtils.getUserId())
                    .put("term", 1);
            ZzuulFeign.AddMessage(data);

            if (getBillPayMonRentOther != null || getBillPayMonRentOther.size() > 0) {
                log.info("-----------------");
                log.info("-----------------");
                log.info("-----------------"+getBillPayMonRentOther);
                log.info("-----------------");
                log.info("-----------------");
                //查询微信账单是否支付成功
                if (getBillPayMonRentOther.get("Status").equals(1) || Integer.valueOf(getBillPayMonRentOther.get("Status").toString())== 1) {
                    //修改合同状态
                    HouseFeign.UpdatePayPact(new HashMap<String, Object>() {{
                        put("PaId", params.get("PaId"));//合同编号
                        put("Hydropower", "3");//水电押金   支付状态   0不需要支付   1.待支付   2支付完成    3待审核
                    }});

                    resultMap.put("PayStatus", "0");//支付宝线下转账是否成功  0成功   1未支付
                    resultMap.put("WechatStatus", "1");//微信线上是否支付成功   0成功  1未支付
                    return result.put(resultMap);
                }
                //查询微信账单是否支付成功
                if (getBillPayMonRentOther.get("Status").equals(2) || Integer.valueOf(getBillPayMonRentOther.get("Status").toString())== 2) {
                    //修改合同状态
                    HouseFeign.UpdatePayPact(new HashMap<String, Object>() {{
                        put("PaId", params.get("PaId"));//合同编号
                        put("Hydropower", "3");//水电押金   支付状态   0不需要支付   1.待支付   2支付完成    3待审核
                    }});

                    resultMap.put("PayStatus", "0");//支付宝线下转账是否成功  0成功   1未支付
                    resultMap.put("WechatStatus", "0");//微信线上是否支付成功   0成功  1未支付
                    return result.put(resultMap);
                }
                if (!FieldCheckUtil.isMapFieldNotNull(getBillPayMonRentOther, new String[]{"PayId"}) &&
                        !FieldCheckUtil.isMapFieldNotNull(getBillPayMonRentOther, new String[]{"Status"})) {
                    //修改合同状态
                    HouseFeign.UpdatePayPact(new HashMap<String, Object>() {{
                        put("PaId", params.get("PaId"));//合同编号
                        put("Hydropower", "3");//水电押金   支付状态   0不需要支付   1.待支付   2支付完成    3待审核
                    }});

                    resultMap.put("PayStatus", "0");//支付宝线下转账是否成功  0成功   1未支付
                    resultMap.put("WechatStatus", "1");//微信线上是否支付成功   0成功  1未支付
                    return result.put(resultMap);
                }
            } else {
                //修改合同状态
                HouseFeign.UpdatePayPact(new HashMap<String, Object>() {{
                    put("PaId", params.get("PaId"));//合同编号
                    put("Hydropower", "3");//水电押金   支付状态   0不需要支付   1.待支付   2支付完成    3待审核
                }});

                resultMap.put("PayStatus", "0");//支付宝线下转账是否成功  0成功   1未支付
                resultMap.put("WechatStatus", "0");//微信线上是否支付成功   0成功  1未支付
                return result.put(resultMap);
            }
        } catch (NumberFormatException e) {
            e.printStackTrace();
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        }
        return result;
    }

    /**
     * 功能描述: 
     * 根据账单编号获取账单基本资料
     * @Author zhlu
     * @Description //TODO
     * @Date 2019/4/28 11:28
     */
    public Map<String,Object>getTrenantBill(Map<String,Object>params){
        //获取账单基本资料
        Map<String,Object>getTrenantBill=BillMapper.getTrenantBill(params);
        //账单类型  1.房租（合同） 2.公共事业费  3.维修费用
        //4.延期退  5.其他费用  6.退租账单 7.夜间开门
        String BiType=getTrenantBill.get("BiType").toString();
        //公共事业费的费用类型   1.水费  2.电费  3.燃气
        //只有账单类型为2才有
        String PubType=getTrenantBill.get("PubType").toString();
        switch (BiType){
            case "1"://房租（合同）
                JsonResult jsonResult=HouseFeign.getTrenantBillPact(getTrenantBill);
                if(jsonResult.isSuccess()==true){
                    Map<String,Object>getTrenantBillPact=(Map<String,Object>)jsonResult.getResult();
                    getTrenantBill.putAll(getTrenantBillPact);
                }
                break;
            case "2"://公共事业费
                switch (PubType){
                    case "1":
                        //水费抄表记录
                        Map<String,Object>getTrenantBillWater=BillMapper.getTrenantBillWater(getTrenantBill);
                        getTrenantBill.putAll(getTrenantBillWater);
                        break;
                    case "2":
                        //电抄表记录
                        Map<String,Object>getTrenantBillEle=BillMapper.getTrenantBillWater(getTrenantBill);
                        getTrenantBill.putAll(getTrenantBillEle);
                        break;
                    case "3":
                        //燃气抄表记录
                        Map<String,Object>getTrenantBillGas=BillMapper.getTrenantBillWater(getTrenantBill);
                        getTrenantBill.putAll(getTrenantBillGas);
                        break;
                }
        }
        return getTrenantBill;
    }

    /**
     * 功能描述: 
     * 根据账单资料生成账单支付信息
     * @Author zhlu
     * @Description //TODO
     * @Date 2019/4/29 19:46
     */
    public Map<String,Object>setPayWechatBill(Map<String,Object>params)throws Exception{
        Map<String,Object>wecaht=new HashMap<String,Object>();

        //获取账单资料
        Map<String,Object>getTrenantBill=BillMapper.getTrenantBill(params);
        //获取权限当前公司的微信支付
        JsonResult<Map<String, Object>> jsonResult = ZuulFeign.getAreaPayMap(new HashMap<String, Object>() {{
            put("AreaId", getTrenantBill.get("CorId"));//当前归属公司
        }});
        if (jsonResult.isSuccess() == false) {//如果网关查询失败就用默认的
            getTrenantBill.put("ServeType", "2");//支付模式      1.服务商模式   2.普通商户
            getTrenantBill.put("MchId", WeChatConfig.DEFAULT_MCH_ID);//默认商户号
            getTrenantBill.put("AppSecret", WeChatConfig.DEFAULT_KEY);//默认微信AppSecret
        } else {
            Map<String, Object> getAreaPayMap = jsonResult.getResult();
            if (getAreaPayMap != null && getAreaPayMap.size() > 0) {//获取权限当前公司的微信支付不等于空
                getTrenantBill.putAll(getAreaPayMap);//把权限查询过来的微信支付资料赋值给当前对象
            } else {
                getTrenantBill.put("ServeType", "2");//支付模式      1.服务商模式   2.普通商户
                getTrenantBill.put("MchId", WeChatConfig.DEFAULT_MCH_ID);//默认商户号
                getTrenantBill.put("AppSecret", WeChatConfig.DEFAULT_KEY);//默认微信AppSecret
            }
        }

        if(MapUtils.isNotEmpty(getTrenantBill)){
            //根据账单编号获取账单未支付账单资料
            Map<String, Object> getPayWechat = BillMapper.getPayWechat(new HashMap<String, Object>() {{
                put("SouType", getTrenantBill.get("BiType"));
                put("Source", getTrenantBill.get("BiId"));
            }});
            //说明有该账单的微信未支付资料，就直接拿过来
            if (MapUtils.isNotEmpty(getPayWechat)) {
                wecaht.putAll(getPayWechat);
            } else {//没有就生成微信支付的资料，并且保存下来
                Map<String,Object>wecaht2=new HashMap<String,Object>();
                if (getTrenantBill.get("ServeType").equals(1) || getTrenantBill.get("ServeType").toString() == "1") {
                    wecaht2.put("SubMchId", getTrenantBill.get("SubMchId"));//父商户号
                }
                wecaht2.put("ServeType", getTrenantBill.get("ServeType"));//支付模式      1.服务商模式   2.普通商户
                wecaht2.put("MchId", getTrenantBill.get("MchId"));//当前商户号
                wecaht2.put("AppSecret", getTrenantBill.get("AppSecret"));//微信AppSecret
                wecaht2.put("body", getTrenantBill.get("BiName"));//商品描述
                wecaht2.put("detail", getTrenantBill.get("BillExplain"));//商品详情
                wecaht2.put("payord", getTrenantBill.get("BiId"));//微信账单号，直接拿账单编号
                wecaht2.put("remoteIp", params.get("remoteIp"));//用户IP
                wecaht2.put("uopid", params.get("uopid"));//用户openID

                //优惠券相关
                if(FieldCheckUtil.isMapFieldNotNull(params,new String[]{"CouId"})){
                    JsonResult jsonResultCou=BaseTenantFeign.getTenantCouCount(new HashMap<String,Object>(){{
                        put("CouId",params.get("CouId"));
                        put("TenId",params.get("TenId"));
                    }});
                    //返回成功
                    if(jsonResultCou.isSuccess()==true){
                        Map<String,Object> getTenantCouCount=(Map<String,Object>) jsonResultCou.getResult();
                        //优惠券大于0
                        if(MapUtils.isNotEmpty(getTenantCouCount)){
                            //账单金额
                            double BiMoney=Double.valueOf(getTrenantBill.get("BiMoney").toString());
                            //优惠券金额
                            double Facevalue=Double.valueOf(getTenantCouCount.get("Facevalue").toString());
                            wecaht2.put("amount",CompuUtils.reduce(BiMoney,Facevalue));//商品总价
                        }
                    }
                }else{
                    wecaht2.put("amount", getTrenantBill.get("BiMoney"));//商品总价
                }

                log.info("微信准备资料wecaht2--------------"+wecaht2);


                //微信支付资料
                Map<String, Object> wecaht1 = WxEncodeUtil.WechatSign(wecaht2);

                log.info("微信返回资料wecaht1--------------"+wecaht1);


                //新增至微信未完成支付信息里面。做二次发起用
                BillMapper.AddPayWechat(new HashMap<String, Object>() {{
                    putAll(wecaht1);
                    put("appId", WeChatConfig.APP_ID);
                    put("SouType", getTrenantBill.get("BiType"));
                    put("Source", getTrenantBill.get("BiId"));
                }});
                wecaht.putAll(wecaht1);
//                wecaht.put("SouType", getTrenantBill.get("BiType"));//房租
                wecaht.put("Source", getTrenantBill.get("BiId"));
            }
        }
        return wecaht;
    }

    /**
     * 功能描述: 
     * 微信账单完成支付验证
     * @Author zhlu
     * @Description //TODO
     * @Date 2019/4/30 9:53
     */
    public  JsonResult PayWechatBillCensor(Map<String,Object>params)throws Exception{
        JsonResult result = new JsonResult();

        //获取账单资料
        Map<String,Object>getTrenantBill=BillMapper.getTrenantBill(params);
        //获取权限当前公司的微信支付
        JsonResult<Map<String, Object>> jsonResult = ZuulFeign.getAreaPayMap(new HashMap<String, Object>() {{
            put("AreaId", getTrenantBill.get("CorId"));//当前归属公司
        }});

        //修改处理
        Map<String, Object> commonUpdateParms = new HashMap<String, Object>();
        commonUpdateParms.put("BiId", params.get("BiId"));//唐巢账单编号
        commonUpdateParms.put("term", "1");// 创建端 Insert端： 1 租客端 2市场部 3 工程部   4运营部   5财务部  6总经办 7发展部
        commonUpdateParms.put("fnc",
                this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
        ParamsCommon.commonUpdateParms(commonUpdateParms);


        if (jsonResult.isSuccess() == true) {//如果网关查询返回成功，就去查询当前订单
            Map<String, Object> Wechat = new HashMap<String, Object>();
            Map<String, Object> getAreaPayMap = jsonResult.getResult();
            if (MapUtils.isNotEmpty(getAreaPayMap)) {//获取权限当前公司的微信支付不等于空
                Wechat.putAll(getAreaPayMap);//把权限查询过来的微信支付资料赋值给当前对象
                Wechat.put("payord", params.get("BiId"));//微信订单号
            } else {
                Wechat.put("payord", params.get("BiId"));//微信订单号
                Wechat.put("ServeType", "2");//支付模式      1.服务商模式   2.普通商户
                Wechat.put("MchId", WeChatConfig.DEFAULT_MCH_ID);//默认商户号
                Wechat.put("AppSecret", WeChatConfig.DEFAULT_KEY);//默认微信AppSecret
            }

            //根据当前账单编号去微信查询当前账单状态
            Map<String, Object> wechatOrderQuery = WxEncodeUtil.wechatOrderQuery(Wechat);
            //说明账单支付是成功的。
            if (wechatOrderQuery.get("messageCode").equals("0") || wechatOrderQuery.toString() == "0") {

                //查询微信订单支付成功
                if (wechatOrderQuery.get("trade_state").equals("SUCCESS")) {
                    lock.lock();
                    try {
                        try {
                            //支付信息
                            Map<String, Object> payId = utilsMapper.getUUID(new HashMap<String, Object>() {{
                                put("uuid", "PayId");
                                put("database", Constants.DATA_SOURCE_GMIO);
                                put("surface", "tcgmio_bill_pay");
                            }});
                            if (payId != null) {
                                int number = Integer.valueOf(payId.get("uuid").toString());
                                PayId = ComUtils.getLocalTrmSeqNum("zf", number);
                            } else {
                                PayId = ComUtils.getLocalTrmSeqNum("zf", 0);
                            }

                            //所有新增处理
                            Map<String, Object> commonInsertParms = new HashMap<String, Object>();
                            commonInsertParms.put("term", "1");// 创建端 Insert端： 1 租客端 2市场部 3 工程部   4运营部   5财务部  6总经办 7发展部
                            commonInsertParms.put("fnc",
                                    this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
                            ParamsCommon.commonInsertParms(commonInsertParms);

                            Map<String, Object> AddPayWechat = new HashMap<String, Object>();
                            AddPayWechat.putAll(commonInsertParms);
                            AddPayWechat.put("PayId", PayId);//支付信息编号
                            AddPayWechat.put("TenId", params.get("TenId"));//用户编号
                            AddPayWechat.put("Shape", "0");//支付形式   0.线上   1.线下
                            AddPayWechat.put("PayMode", "1");//支付方式  1.微信  2.支付宝
                            AddPayWechat.put("TransactionId", wechatOrderQuery.get("transaction_id"));//微信支付订单号	该字段只有线上微信支付才有
                            AddPayWechat.put("PayTime", wechatOrderQuery.get("time_end"));//支付时间
                            AddPayWechat.put("BiMoney", getTrenantBill.get("BiMoney"));//本次账单金额
                            double total_fee = Double.valueOf(wechatOrderQuery.get("total_fee").toString());
                            AddPayWechat.put("PayMoney", CompuUtils.div(total_fee, 100, 2));//支付金额
                            AddPayWechat.put("PatStats", "2");//支付状态    1.未支付  2.支付成功
                            //优惠券相关
                            if(FieldCheckUtil.isMapFieldNotNull(params,new String[]{"CouId"})){
                                JsonResult jsonResultCou=BaseTenantFeign.getTenantCouCount(new HashMap<String,Object>(){{
                                    put("CouId",params.get("CouId"));
                                    put("TenId",params.get("TenId"));
                                }});
                                //返回成功
                                if(jsonResultCou.isSuccess()==true){
                                    Map<String,Object> getTenantCouCount=(Map<String,Object>) jsonResultCou.getResult();
                                    //优惠券大于0
                                    if(MapUtils.isNotEmpty(getTenantCouCount)){
                                        Map<String,Object>cou=new HashMap<String,Object>();
                                        cou.put("CouId",params.get("CouId"));
                                        cou.put("TenId",params.get("TenId"));
                                        //修改优惠券已使用
                                        BaseTenantFeign.UpdateTenantCou(cou);
                                        AddPayWechat.put("Couponcd", params.get("CouId"));//优惠券编号
                                        AddPayWechat.put("Couponamt",getTenantCouCount.get("Facevalue"));//优惠券金额
                                    }
                                }
                            }

                            log.info("AddPayWechat支付信息-------------"+AddPayWechat);

                            //新增支付信息
                            BillMapper.AddBillPay(AddPayWechat);

                            //修改当前房租账单为支付成功
                            BillMapper.UpdateBill(new HashMap<String, Object>() {{
                                putAll(commonUpdateParms);
                                put("PayId", PayId);//支付信息编号
                                put("Status", 2);//账单状态   1.待支付  2.支付完成
                                put("Abnormal", 0);//账单异常状态   0正常   1异常
                            }});
                            log.info("-----------------");
                            log.info("-----------------");
                            log.info("-----------------"+getTrenantBill);
                            log.info("-----------------");
                            log.info("-----------------");

                           return result.putSuccess("支付成功！");

                        } catch (NumberFormatException e) {
                            e.printStackTrace();
                            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                        }
                    } finally {
                        lock.unlock();
                    }
                }//查询微信支付中除开支付成功状态，其他状态。先返回支付成功，并且标明账单异常
                else {
                    BillMapper.UpdateBill(new HashMap<String, Object>() {{
                        putAll(commonUpdateParms);
                        put("Abnormal", 1);//账单异常状态   0正常   1异常
                        put("Status", 2);//账单状态   1.待支付  2.支付完成
                    }});

                    return result.putSuccess("支付成功！");
                }
            }
            //账单查询失败，就把错误信息返回
            else if (wechatOrderQuery.get("messageCode").equals("400") || wechatOrderQuery.toString() == "400") {
                result.putSuccess(wechatOrderQuery.get("messageStr").toString());
                return result;
            }
        } else {//如果网关查询失败，把当前账单标记为异常，并且标记当前账单支付完成
            BillMapper.UpdateBill(new HashMap<String, Object>() {{
                putAll(commonUpdateParms);
                put("Abnormal", 1);//账单异常状态   0正常   1异常
                put("Status", 2);//账单状态   1.待支付  2.支付完成
            }});

            return result.putSuccess("支付成功！");
        }

        return result;
    }

    /**
     * 功能描述: 
     * 根据维修编号获取账单资料
     * @Author zhlu
     * @Description //TODO
     * @Date 2019/5/10 14:43
     */
    public Map<String,Object>getRepairBillMap(Map<String,Object>params){
        return BillMapper.getRepairBillMap(params);
    }

    /**
     * 获取首月账单
     * @param params
     * @return
     */
    public Map<String, Object> getFirstRoomGEW(Map<String,Object> params){
        return BillMapper.getFirsMonRent(params);
    }

    /**
     * 增加支付信息
     * @param params
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    public Integer AddBillPay(Map<String,Object> params){

        Integer cout = new Integer("0");

        lock.lock();
        try {

            cout =BillMapper.AddBillPay(params);
        } catch (Exception e) {
            e.printStackTrace();
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();//事务回滚
        } finally {
            lock.unlock();
        }

        return cout;


    }

    /**
     * 修改订单信息
     * @param params
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    public Integer UpdateBill(Map<String,Object> params){

        Integer cout = new Integer("0");

        lock.lock();
        try {

            cout =BillMapper.UpdateBill(params);
        } catch (Exception e) {
            e.printStackTrace();
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();//事务回滚
        } finally {
            lock.unlock();
        }

        return cout;

    }

    /**
     * 保存微信支付订单id
     * @param params
     * @return
     */

    @Transactional(rollbackFor = Exception.class)
    public Integer AddPayWechat(Map<String,Object> params){

        Integer cout = new Integer("0");

        lock.lock();
        try {

            cout =BillMapper.AddPayWechat(params);
        } catch (Exception e) {
            e.printStackTrace();
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();//事务回滚
        } finally {
            lock.unlock();
        }

        return cout;

    }

    /**
     * 根据订单号查询关联账单id
     * @param params
     * @return
     */
    public List<Map<String,Object>> getBillPay(Map<String,Object> params){
        return BillMapper.getBillPay(params);
    }

    /**
     * 增加账单
     * @param params
     * @return
     * @return
     */

    @Transactional(rollbackFor = Exception.class)
    public Integer addTenantBill(Map<String,Object> params){
        Integer cout = new Integer("0");

        lock.lock();
        try {

            cout =seTenantBillMapper.addTenantBill(params);
        } catch (Exception e) {
            e.printStackTrace();
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();//事务回滚
        } finally {
            lock.unlock();
        }

        return cout;
    }


    public JsonResult getBillPays(Map<String,Object> params){
        JsonResult result = new JsonResult();
        Map<String,Object> map1 = new HashMap<>();
        map1.put("coutPay",BillMapper.getBillPays(params));
        return result.put(map1);
    }
    public JsonResult geiTenBill(Map<String,Object> params){
        JsonResult result = new JsonResult();
        Map<String,Object> map1 = new HashMap<>();
        map1.put("coutBill",BillMapper.geiTenBill(params));
        return result.put(map1);
    }





    /**
     * 增加账单
     * @param params
     * @return
     * @return
     */

    @Transactional(rollbackFor = Exception.class)
    public Integer UpdateWechat(Map<String,Object> params){
        Integer cout = new Integer("0");

        lock.lock();
        try {


            params.put("IsBill",1);
            params.put("term","7");//1 租客端 2市场部 3 工程部 4运营部 5财务部 6总经办 7发展部
            params.put("fnc",
                    this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
            ParamsCommon.commonUpdateParms(params);
            cout =BillMapper.UpdateWechat(params);
        } catch (Exception e) {
            e.printStackTrace();
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();//事务回滚
        } finally {
            lock.unlock();
        }

        return cout;
    }











}
